/*
 * Copyright Codeplay Software Ltd.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use these files except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

// DO NOT MODIFY BY HAND
// This file was automatically generated by generate_pooling_tests.py.
// Results calculated using Tensorflow v1.12.0.

#include <gtest/gtest.h>

#include "sycldnn/padding_mode.h"

#include "sycldnn/pooling/operators.h"

#include "test/types/cartesian_product.h"
#include "test/types/kernel_data_types.h"
#include "test/types/test_backend_types.h"
#include "test/types/to_gtest_types.h"

#include "test/pooling/pooling_fixture.h"

#include <array>
#include <vector>

using namespace sycldnn;  // NOLINT(google-build-using-namespace)
using DataTypeList = sycldnn::types::KernelDataTypes;
using Backends = sycldnn::types::DefaultBackendTypes;

using SNNTypePairs =
    sycldnn::types::CartesianProduct<DataTypeList, Backends>::type;
using GTestTypePairs = sycldnn::types::ToGTestTypes<SNNTypePairs>::type;

template <typename Pair>
using MaxwithnanWindow5Stride2Forward =
    PoolingFixture<typename Pair::FirstType, typename Pair::SecondType,
                   pooling::MaxWithNan, pooling::Forward>;
TYPED_TEST_SUITE(MaxwithnanWindow5Stride2Forward, GTestTypePairs);
TYPED_TEST(MaxwithnanWindow5Stride2Forward, SAME1x7x7x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {17., 19., 21., 21., 31., 33.,
                                         35., 35., 45., 47., 49., 49.,
                                         45., 47., 49., 49.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, VALID1x7x7x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {33., 35., 47., 49.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, SAME1x7x7x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      33., 34., 37., 38., 41., 42., 41., 42., 61., 62., 65.,
      66., 69., 70., 69., 70., 89., 90., 93., 94., 97., 98.,
      97., 98., 89., 90., 93., 94., 97., 98., 97., 98.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, VALID1x7x7x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {65., 66., 69., 70.,
                                         93., 94., 97., 98.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, SAME1x7x7x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      65.,  66.,  67.,  68.,  73.,  74.,  75.,  76.,  81.,  82.,  83.,
      84.,  81.,  82.,  83.,  84.,  121., 122., 123., 124., 129., 130.,
      131., 132., 137., 138., 139., 140., 137., 138., 139., 140., 177.,
      178., 179., 180., 185., 186., 187., 188., 193., 194., 195., 196.,
      193., 194., 195., 196., 177., 178., 179., 180., 185., 186., 187.,
      188., 193., 194., 195., 196., 193., 194., 195., 196.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, VALID1x7x7x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {129., 130., 131., 132., 137., 138.,
                                         139., 140., 185., 186., 187., 188.,
                                         193., 194., 195., 196.};
  const std::array<int, 4> in_shape = {{1, 7, 7, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, SAME1x7x8x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {20., 22., 24., 24., 36., 38.,
                                         40., 40., 52., 54., 56., 56.,
                                         52., 54., 56., 56.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, VALID1x7x8x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {37., 39., 53., 55.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, SAME1x7x8x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      39.,  40.,  43.,  44.,  47.,  48.,  47.,  48.,  71.,  72.,  75.,
      76.,  79.,  80.,  79.,  80.,  103., 104., 107., 108., 111., 112.,
      111., 112., 103., 104., 107., 108., 111., 112., 111., 112.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, VALID1x7x8x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {73.,  74.,  77.,  78.,
                                         105., 106., 109., 110.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, SAME1x7x8x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      77.,  78.,  79.,  80.,  85.,  86.,  87.,  88.,  93.,  94.,  95.,
      96.,  93.,  94.,  95.,  96.,  141., 142., 143., 144., 149., 150.,
      151., 152., 157., 158., 159., 160., 157., 158., 159., 160., 205.,
      206., 207., 208., 213., 214., 215., 216., 221., 222., 223., 224.,
      221., 222., 223., 224., 205., 206., 207., 208., 213., 214., 215.,
      216., 221., 222., 223., 224., 221., 222., 223., 224.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, VALID1x7x8x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {145., 146., 147., 148., 153., 154.,
                                         155., 156., 209., 210., 211., 212.,
                                         217., 218., 219., 220.};
  const std::array<int, 4> in_shape = {{1, 7, 8, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, SAME1x7x10x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {24., 26., 28., 30., 30., 44., 46.,
                                         48., 50., 50., 64., 66., 68., 70.,
                                         70., 64., 66., 68., 70., 70.};
  const std::array<int, 4> in_shape = {{1, 7, 10, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, VALID1x7x10x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {45., 47., 49., 65., 67., 69.};
  const std::array<int, 4> in_shape = {{1, 7, 10, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, SAME1x7x10x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      47.,  48.,  51.,  52.,  55.,  56.,  59.,  60.,  59.,  60.,
      87.,  88.,  91.,  92.,  95.,  96.,  99.,  100., 99.,  100.,
      127., 128., 131., 132., 135., 136., 139., 140., 139., 140.,
      127., 128., 131., 132., 135., 136., 139., 140., 139., 140.};
  const std::array<int, 4> in_shape = {{1, 7, 10, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, VALID1x7x10x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {89.,  90.,  93.,  94.,  97.,  98.,
                                         129., 130., 133., 134., 137., 138.};
  const std::array<int, 4> in_shape = {{1, 7, 10, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, SAME1x7x10x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      93.,  94.,  95.,  96.,  101., 102., 103., 104., 109., 110., 111., 112.,
      117., 118., 119., 120., 117., 118., 119., 120., 173., 174., 175., 176.,
      181., 182., 183., 184., 189., 190., 191., 192., 197., 198., 199., 200.,
      197., 198., 199., 200., 253., 254., 255., 256., 261., 262., 263., 264.,
      269., 270., 271., 272., 277., 278., 279., 280., 277., 278., 279., 280.,
      253., 254., 255., 256., 261., 262., 263., 264., 269., 270., 271., 272.,
      277., 278., 279., 280., 277., 278., 279., 280.};
  const std::array<int, 4> in_shape = {{1, 7, 10, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, VALID1x7x10x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      177., 178., 179., 180., 185., 186., 187., 188., 193., 194., 195., 196.,
      257., 258., 259., 260., 265., 266., 267., 268., 273., 274., 275., 276.};
  const std::array<int, 4> in_shape = {{1, 7, 10, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, SAME1x8x7x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {24., 26., 28., 28., 38., 40.,
                                         42., 42., 52., 54., 56., 56.,
                                         52., 54., 56., 56.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, VALID1x8x7x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {33., 35., 47., 49.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, SAME1x8x7x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      47.,  48.,  51.,  52.,  55.,  56.,  55.,  56.,  75.,  76.,  79.,
      80.,  83.,  84.,  83.,  84.,  103., 104., 107., 108., 111., 112.,
      111., 112., 103., 104., 107., 108., 111., 112., 111., 112.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, VALID1x8x7x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {65., 66., 69., 70.,
                                         93., 94., 97., 98.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, SAME1x8x7x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      93.,  94.,  95.,  96.,  101., 102., 103., 104., 109., 110., 111.,
      112., 109., 110., 111., 112., 149., 150., 151., 152., 157., 158.,
      159., 160., 165., 166., 167., 168., 165., 166., 167., 168., 205.,
      206., 207., 208., 213., 214., 215., 216., 221., 222., 223., 224.,
      221., 222., 223., 224., 205., 206., 207., 208., 213., 214., 215.,
      216., 221., 222., 223., 224., 221., 222., 223., 224.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, VALID1x8x7x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {129., 130., 131., 132., 137., 138.,
                                         139., 140., 185., 186., 187., 188.,
                                         193., 194., 195., 196.};
  const std::array<int, 4> in_shape = {{1, 8, 7, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, SAME1x8x8x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {28., 30., 32., 32., 44., 46.,
                                         48., 48., 60., 62., 64., 64.,
                                         60., 62., 64., 64.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, VALID1x8x8x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {37., 39., 53., 55.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, SAME1x8x8x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      55.,  56.,  59.,  60.,  63.,  64.,  63.,  64.,  87.,  88.,  91.,
      92.,  95.,  96.,  95.,  96.,  119., 120., 123., 124., 127., 128.,
      127., 128., 119., 120., 123., 124., 127., 128., 127., 128.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, VALID1x8x8x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {73.,  74.,  77.,  78.,
                                         105., 106., 109., 110.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, SAME1x8x8x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      109., 110., 111., 112., 117., 118., 119., 120., 125., 126., 127.,
      128., 125., 126., 127., 128., 173., 174., 175., 176., 181., 182.,
      183., 184., 189., 190., 191., 192., 189., 190., 191., 192., 237.,
      238., 239., 240., 245., 246., 247., 248., 253., 254., 255., 256.,
      253., 254., 255., 256., 237., 238., 239., 240., 245., 246., 247.,
      248., 253., 254., 255., 256., 253., 254., 255., 256.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, VALID1x8x8x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {145., 146., 147., 148., 153., 154.,
                                         155., 156., 209., 210., 211., 212.,
                                         217., 218., 219., 220.};
  const std::array<int, 4> in_shape = {{1, 8, 8, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, SAME1x8x10x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {34., 36., 38., 40., 40., 54., 56.,
                                         58., 60., 60., 74., 76., 78., 80.,
                                         80., 74., 76., 78., 80., 80.};
  const std::array<int, 4> in_shape = {{1, 8, 10, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, VALID1x8x10x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {45., 47., 49., 65., 67., 69.};
  const std::array<int, 4> in_shape = {{1, 8, 10, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, SAME1x8x10x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      67.,  68.,  71.,  72.,  75.,  76.,  79.,  80.,  79.,  80.,
      107., 108., 111., 112., 115., 116., 119., 120., 119., 120.,
      147., 148., 151., 152., 155., 156., 159., 160., 159., 160.,
      147., 148., 151., 152., 155., 156., 159., 160., 159., 160.};
  const std::array<int, 4> in_shape = {{1, 8, 10, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, VALID1x8x10x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {89.,  90.,  93.,  94.,  97.,  98.,
                                         129., 130., 133., 134., 137., 138.};
  const std::array<int, 4> in_shape = {{1, 8, 10, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, SAME1x8x10x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      133., 134., 135., 136., 141., 142., 143., 144., 149., 150., 151., 152.,
      157., 158., 159., 160., 157., 158., 159., 160., 213., 214., 215., 216.,
      221., 222., 223., 224., 229., 230., 231., 232., 237., 238., 239., 240.,
      237., 238., 239., 240., 293., 294., 295., 296., 301., 302., 303., 304.,
      309., 310., 311., 312., 317., 318., 319., 320., 317., 318., 319., 320.,
      293., 294., 295., 296., 301., 302., 303., 304., 309., 310., 311., 312.,
      317., 318., 319., 320., 317., 318., 319., 320.};
  const std::array<int, 4> in_shape = {{1, 8, 10, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, VALID1x8x10x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      177., 178., 179., 180., 185., 186., 187., 188., 193., 194., 195., 196.,
      257., 258., 259., 260., 265., 266., 267., 268., 273., 274., 275., 276.};
  const std::array<int, 4> in_shape = {{1, 8, 10, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, SAME1x10x7x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {24., 26., 28., 28., 38., 40., 42.,
                                         42., 52., 54., 56., 56., 66., 68.,
                                         70., 70., 66., 68., 70., 70.};
  const std::array<int, 4> in_shape = {{1, 10, 7, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, VALID1x10x7x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {33., 35., 47., 49., 61., 63.};
  const std::array<int, 4> in_shape = {{1, 10, 7, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, SAME1x10x7x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      47.,  48.,  51.,  52.,  55.,  56.,  55.,  56.,  75.,  76.,
      79.,  80.,  83.,  84.,  83.,  84.,  103., 104., 107., 108.,
      111., 112., 111., 112., 131., 132., 135., 136., 139., 140.,
      139., 140., 131., 132., 135., 136., 139., 140., 139., 140.};
  const std::array<int, 4> in_shape = {{1, 10, 7, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, VALID1x10x7x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {65., 66., 69.,  70.,  93.,  94.,
                                         97., 98., 121., 122., 125., 126.};
  const std::array<int, 4> in_shape = {{1, 10, 7, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, SAME1x10x7x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      93.,  94.,  95.,  96.,  101., 102., 103., 104., 109., 110., 111., 112.,
      109., 110., 111., 112., 149., 150., 151., 152., 157., 158., 159., 160.,
      165., 166., 167., 168., 165., 166., 167., 168., 205., 206., 207., 208.,
      213., 214., 215., 216., 221., 222., 223., 224., 221., 222., 223., 224.,
      261., 262., 263., 264., 269., 270., 271., 272., 277., 278., 279., 280.,
      277., 278., 279., 280., 261., 262., 263., 264., 269., 270., 271., 272.,
      277., 278., 279., 280., 277., 278., 279., 280.};
  const std::array<int, 4> in_shape = {{1, 10, 7, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, VALID1x10x7x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      129., 130., 131., 132., 137., 138., 139., 140., 185., 186., 187., 188.,
      193., 194., 195., 196., 241., 242., 243., 244., 249., 250., 251., 252.};
  const std::array<int, 4> in_shape = {{1, 10, 7, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, SAME1x10x8x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {28., 30., 32., 32., 44., 46., 48.,
                                         48., 60., 62., 64., 64., 76., 78.,
                                         80., 80., 76., 78., 80., 80.};
  const std::array<int, 4> in_shape = {{1, 10, 8, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, VALID1x10x8x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {37., 39., 53., 55., 69., 71.};
  const std::array<int, 4> in_shape = {{1, 10, 8, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, SAME1x10x8x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      55.,  56.,  59.,  60.,  63.,  64.,  63.,  64.,  87.,  88.,
      91.,  92.,  95.,  96.,  95.,  96.,  119., 120., 123., 124.,
      127., 128., 127., 128., 151., 152., 155., 156., 159., 160.,
      159., 160., 151., 152., 155., 156., 159., 160., 159., 160.};
  const std::array<int, 4> in_shape = {{1, 10, 8, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, VALID1x10x8x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {73.,  74.,  77.,  78.,  105., 106.,
                                         109., 110., 137., 138., 141., 142.};
  const std::array<int, 4> in_shape = {{1, 10, 8, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, SAME1x10x8x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      109., 110., 111., 112., 117., 118., 119., 120., 125., 126., 127., 128.,
      125., 126., 127., 128., 173., 174., 175., 176., 181., 182., 183., 184.,
      189., 190., 191., 192., 189., 190., 191., 192., 237., 238., 239., 240.,
      245., 246., 247., 248., 253., 254., 255., 256., 253., 254., 255., 256.,
      301., 302., 303., 304., 309., 310., 311., 312., 317., 318., 319., 320.,
      317., 318., 319., 320., 301., 302., 303., 304., 309., 310., 311., 312.,
      317., 318., 319., 320., 317., 318., 319., 320.};
  const std::array<int, 4> in_shape = {{1, 10, 8, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, VALID1x10x8x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      145., 146., 147., 148., 153., 154., 155., 156., 209., 210., 211., 212.,
      217., 218., 219., 220., 273., 274., 275., 276., 281., 282., 283., 284.};
  const std::array<int, 4> in_shape = {{1, 10, 8, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, SAME1x10x10x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      34., 36., 38., 40., 40., 54.,  56.,  58., 60., 60., 74.,  76., 78.,
      80., 80., 94., 96., 98., 100., 100., 94., 96., 98., 100., 100.};
  const std::array<int, 4> in_shape = {{1, 10, 10, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, VALID1x10x10x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {45., 47., 49., 65., 67.,
                                         69., 85., 87., 89.};
  const std::array<int, 4> in_shape = {{1, 10, 10, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, SAME1x10x10x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      67.,  68.,  71.,  72.,  75.,  76.,  79.,  80.,  79.,  80.,
      107., 108., 111., 112., 115., 116., 119., 120., 119., 120.,
      147., 148., 151., 152., 155., 156., 159., 160., 159., 160.,
      187., 188., 191., 192., 195., 196., 199., 200., 199., 200.,
      187., 188., 191., 192., 195., 196., 199., 200., 199., 200.};
  const std::array<int, 4> in_shape = {{1, 10, 10, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, VALID1x10x10x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {89.,  90.,  93.,  94.,  97.,  98.,
                                         129., 130., 133., 134., 137., 138.,
                                         169., 170., 173., 174., 177., 178.};
  const std::array<int, 4> in_shape = {{1, 10, 10, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, SAME1x10x10x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      133., 134., 135., 136., 141., 142., 143., 144., 149., 150., 151., 152.,
      157., 158., 159., 160., 157., 158., 159., 160., 213., 214., 215., 216.,
      221., 222., 223., 224., 229., 230., 231., 232., 237., 238., 239., 240.,
      237., 238., 239., 240., 293., 294., 295., 296., 301., 302., 303., 304.,
      309., 310., 311., 312., 317., 318., 319., 320., 317., 318., 319., 320.,
      373., 374., 375., 376., 381., 382., 383., 384., 389., 390., 391., 392.,
      397., 398., 399., 400., 397., 398., 399., 400., 373., 374., 375., 376.,
      381., 382., 383., 384., 389., 390., 391., 392., 397., 398., 399., 400.,
      397., 398., 399., 400.};
  const std::array<int, 4> in_shape = {{1, 10, 10, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, VALID1x10x10x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      177., 178., 179., 180., 185., 186., 187., 188., 193., 194., 195., 196.,
      257., 258., 259., 260., 265., 266., 267., 268., 273., 274., 275., 276.,
      337., 338., 339., 340., 345., 346., 347., 348., 353., 354., 355., 356.};
  const std::array<int, 4> in_shape = {{1, 10, 10, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, SAME3x7x7x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      17.,  19.,  21.,  21.,  31.,  33.,  35.,  35.,  45.,  47.,  49.,  49.,
      45.,  47.,  49.,  49.,  66.,  68.,  70.,  70.,  80.,  82.,  84.,  84.,
      94.,  96.,  98.,  98.,  94.,  96.,  98.,  98.,  115., 117., 119., 119.,
      129., 131., 133., 133., 143., 145., 147., 147., 143., 145., 147., 147.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, VALID3x7x7x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {33., 35., 47.,  49.,  82.,  84.,
                                         96., 98., 131., 133., 145., 147.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, SAME3x7x7x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      33.,  34.,  37.,  38.,  41.,  42.,  41.,  42.,  61.,  62.,  65.,  66.,
      69.,  70.,  69.,  70.,  89.,  90.,  93.,  94.,  97.,  98.,  97.,  98.,
      89.,  90.,  93.,  94.,  97.,  98.,  97.,  98.,  131., 132., 135., 136.,
      139., 140., 139., 140., 159., 160., 163., 164., 167., 168., 167., 168.,
      187., 188., 191., 192., 195., 196., 195., 196., 187., 188., 191., 192.,
      195., 196., 195., 196., 229., 230., 233., 234., 237., 238., 237., 238.,
      257., 258., 261., 262., 265., 266., 265., 266., 285., 286., 289., 290.,
      293., 294., 293., 294., 285., 286., 289., 290., 293., 294., 293., 294.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, VALID3x7x7x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      65.,  66.,  69.,  70.,  93.,  94.,  97.,  98.,  163., 164., 167., 168.,
      191., 192., 195., 196., 261., 262., 265., 266., 289., 290., 293., 294.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, SAME3x7x7x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      65.,  66.,  67.,  68.,  73.,  74.,  75.,  76.,  81.,  82.,  83.,  84.,
      81.,  82.,  83.,  84.,  121., 122., 123., 124., 129., 130., 131., 132.,
      137., 138., 139., 140., 137., 138., 139., 140., 177., 178., 179., 180.,
      185., 186., 187., 188., 193., 194., 195., 196., 193., 194., 195., 196.,
      177., 178., 179., 180., 185., 186., 187., 188., 193., 194., 195., 196.,
      193., 194., 195., 196., 261., 262., 263., 264., 269., 270., 271., 272.,
      277., 278., 279., 280., 277., 278., 279., 280., 317., 318., 319., 320.,
      325., 326., 327., 328., 333., 334., 335., 336., 333., 334., 335., 336.,
      373., 374., 375., 376., 381., 382., 383., 384., 389., 390., 391., 392.,
      389., 390., 391., 392., 373., 374., 375., 376., 381., 382., 383., 384.,
      389., 390., 391., 392., 389., 390., 391., 392., 457., 458., 459., 460.,
      465., 466., 467., 468., 473., 474., 475., 476., 473., 474., 475., 476.,
      513., 514., 515., 516., 521., 522., 523., 524., 529., 530., 531., 532.,
      529., 530., 531., 532., 569., 570., 571., 572., 577., 578., 579., 580.,
      585., 586., 587., 588., 585., 586., 587., 588., 569., 570., 571., 572.,
      577., 578., 579., 580., 585., 586., 587., 588., 585., 586., 587., 588.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, VALID3x7x7x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      129., 130., 131., 132., 137., 138., 139., 140., 185., 186., 187., 188.,
      193., 194., 195., 196., 325., 326., 327., 328., 333., 334., 335., 336.,
      381., 382., 383., 384., 389., 390., 391., 392., 521., 522., 523., 524.,
      529., 530., 531., 532., 577., 578., 579., 580., 585., 586., 587., 588.};
  const std::array<int, 4> in_shape = {{3, 7, 7, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, SAME3x7x8x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      20.,  22.,  24.,  24.,  36.,  38.,  40.,  40.,  52.,  54.,  56.,  56.,
      52.,  54.,  56.,  56.,  76.,  78.,  80.,  80.,  92.,  94.,  96.,  96.,
      108., 110., 112., 112., 108., 110., 112., 112., 132., 134., 136., 136.,
      148., 150., 152., 152., 164., 166., 168., 168., 164., 166., 168., 168.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, VALID3x7x8x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {37.,  39.,  53.,  55.,  93.,  95.,
                                         109., 111., 149., 151., 165., 167.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, SAME3x7x8x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      39.,  40.,  43.,  44.,  47.,  48.,  47.,  48.,  71.,  72.,  75.,  76.,
      79.,  80.,  79.,  80.,  103., 104., 107., 108., 111., 112., 111., 112.,
      103., 104., 107., 108., 111., 112., 111., 112., 151., 152., 155., 156.,
      159., 160., 159., 160., 183., 184., 187., 188., 191., 192., 191., 192.,
      215., 216., 219., 220., 223., 224., 223., 224., 215., 216., 219., 220.,
      223., 224., 223., 224., 263., 264., 267., 268., 271., 272., 271., 272.,
      295., 296., 299., 300., 303., 304., 303., 304., 327., 328., 331., 332.,
      335., 336., 335., 336., 327., 328., 331., 332., 335., 336., 335., 336.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, VALID3x7x8x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      73.,  74.,  77.,  78.,  105., 106., 109., 110., 185., 186., 189., 190.,
      217., 218., 221., 222., 297., 298., 301., 302., 329., 330., 333., 334.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, SAME3x7x8x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      77.,  78.,  79.,  80.,  85.,  86.,  87.,  88.,  93.,  94.,  95.,  96.,
      93.,  94.,  95.,  96.,  141., 142., 143., 144., 149., 150., 151., 152.,
      157., 158., 159., 160., 157., 158., 159., 160., 205., 206., 207., 208.,
      213., 214., 215., 216., 221., 222., 223., 224., 221., 222., 223., 224.,
      205., 206., 207., 208., 213., 214., 215., 216., 221., 222., 223., 224.,
      221., 222., 223., 224., 301., 302., 303., 304., 309., 310., 311., 312.,
      317., 318., 319., 320., 317., 318., 319., 320., 365., 366., 367., 368.,
      373., 374., 375., 376., 381., 382., 383., 384., 381., 382., 383., 384.,
      429., 430., 431., 432., 437., 438., 439., 440., 445., 446., 447., 448.,
      445., 446., 447., 448., 429., 430., 431., 432., 437., 438., 439., 440.,
      445., 446., 447., 448., 445., 446., 447., 448., 525., 526., 527., 528.,
      533., 534., 535., 536., 541., 542., 543., 544., 541., 542., 543., 544.,
      589., 590., 591., 592., 597., 598., 599., 600., 605., 606., 607., 608.,
      605., 606., 607., 608., 653., 654., 655., 656., 661., 662., 663., 664.,
      669., 670., 671., 672., 669., 670., 671., 672., 653., 654., 655., 656.,
      661., 662., 663., 664., 669., 670., 671., 672., 669., 670., 671., 672.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, VALID3x7x8x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      145., 146., 147., 148., 153., 154., 155., 156., 209., 210., 211., 212.,
      217., 218., 219., 220., 369., 370., 371., 372., 377., 378., 379., 380.,
      433., 434., 435., 436., 441., 442., 443., 444., 593., 594., 595., 596.,
      601., 602., 603., 604., 657., 658., 659., 660., 665., 666., 667., 668.};
  const std::array<int, 4> in_shape = {{3, 7, 8, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, SAME3x7x10x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      24.,  26.,  28.,  30.,  30.,  44.,  46.,  48.,  50.,  50.,  64.,  66.,
      68.,  70.,  70.,  64.,  66.,  68.,  70.,  70.,  94.,  96.,  98.,  100.,
      100., 114., 116., 118., 120., 120., 134., 136., 138., 140., 140., 134.,
      136., 138., 140., 140., 164., 166., 168., 170., 170., 184., 186., 188.,
      190., 190., 204., 206., 208., 210., 210., 204., 206., 208., 210., 210.};
  const std::array<int, 4> in_shape = {{3, 7, 10, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, VALID3x7x10x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {45.,  47.,  49.,  65.,  67.,  69.,
                                         115., 117., 119., 135., 137., 139.,
                                         185., 187., 189., 205., 207., 209.};
  const std::array<int, 4> in_shape = {{3, 7, 10, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, SAME3x7x10x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      47.,  48.,  51.,  52.,  55.,  56.,  59.,  60.,  59.,  60.,  87.,  88.,
      91.,  92.,  95.,  96.,  99.,  100., 99.,  100., 127., 128., 131., 132.,
      135., 136., 139., 140., 139., 140., 127., 128., 131., 132., 135., 136.,
      139., 140., 139., 140., 187., 188., 191., 192., 195., 196., 199., 200.,
      199., 200., 227., 228., 231., 232., 235., 236., 239., 240., 239., 240.,
      267., 268., 271., 272., 275., 276., 279., 280., 279., 280., 267., 268.,
      271., 272., 275., 276., 279., 280., 279., 280., 327., 328., 331., 332.,
      335., 336., 339., 340., 339., 340., 367., 368., 371., 372., 375., 376.,
      379., 380., 379., 380., 407., 408., 411., 412., 415., 416., 419., 420.,
      419., 420., 407., 408., 411., 412., 415., 416., 419., 420., 419., 420.};
  const std::array<int, 4> in_shape = {{3, 7, 10, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, VALID3x7x10x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      89.,  90.,  93.,  94.,  97.,  98.,  129., 130., 133., 134., 137., 138.,
      229., 230., 233., 234., 237., 238., 269., 270., 273., 274., 277., 278.,
      369., 370., 373., 374., 377., 378., 409., 410., 413., 414., 417., 418.};
  const std::array<int, 4> in_shape = {{3, 7, 10, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, SAME3x7x10x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      93.,  94.,  95.,  96.,  101., 102., 103., 104., 109., 110., 111., 112.,
      117., 118., 119., 120., 117., 118., 119., 120., 173., 174., 175., 176.,
      181., 182., 183., 184., 189., 190., 191., 192., 197., 198., 199., 200.,
      197., 198., 199., 200., 253., 254., 255., 256., 261., 262., 263., 264.,
      269., 270., 271., 272., 277., 278., 279., 280., 277., 278., 279., 280.,
      253., 254., 255., 256., 261., 262., 263., 264., 269., 270., 271., 272.,
      277., 278., 279., 280., 277., 278., 279., 280., 373., 374., 375., 376.,
      381., 382., 383., 384., 389., 390., 391., 392., 397., 398., 399., 400.,
      397., 398., 399., 400., 453., 454., 455., 456., 461., 462., 463., 464.,
      469., 470., 471., 472., 477., 478., 479., 480., 477., 478., 479., 480.,
      533., 534., 535., 536., 541., 542., 543., 544., 549., 550., 551., 552.,
      557., 558., 559., 560., 557., 558., 559., 560., 533., 534., 535., 536.,
      541., 542., 543., 544., 549., 550., 551., 552., 557., 558., 559., 560.,
      557., 558., 559., 560., 653., 654., 655., 656., 661., 662., 663., 664.,
      669., 670., 671., 672., 677., 678., 679., 680., 677., 678., 679., 680.,
      733., 734., 735., 736., 741., 742., 743., 744., 749., 750., 751., 752.,
      757., 758., 759., 760., 757., 758., 759., 760., 813., 814., 815., 816.,
      821., 822., 823., 824., 829., 830., 831., 832., 837., 838., 839., 840.,
      837., 838., 839., 840., 813., 814., 815., 816., 821., 822., 823., 824.,
      829., 830., 831., 832., 837., 838., 839., 840., 837., 838., 839., 840.};
  const std::array<int, 4> in_shape = {{3, 7, 10, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, VALID3x7x10x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      177., 178., 179., 180., 185., 186., 187., 188., 193., 194., 195., 196.,
      257., 258., 259., 260., 265., 266., 267., 268., 273., 274., 275., 276.,
      457., 458., 459., 460., 465., 466., 467., 468., 473., 474., 475., 476.,
      537., 538., 539., 540., 545., 546., 547., 548., 553., 554., 555., 556.,
      737., 738., 739., 740., 745., 746., 747., 748., 753., 754., 755., 756.,
      817., 818., 819., 820., 825., 826., 827., 828., 833., 834., 835., 836.};
  const std::array<int, 4> in_shape = {{3, 7, 10, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, SAME3x8x7x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      24.,  26.,  28.,  28.,  38.,  40.,  42.,  42.,  52.,  54.,  56.,  56.,
      52.,  54.,  56.,  56.,  80.,  82.,  84.,  84.,  94.,  96.,  98.,  98.,
      108., 110., 112., 112., 108., 110., 112., 112., 136., 138., 140., 140.,
      150., 152., 154., 154., 164., 166., 168., 168., 164., 166., 168., 168.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, VALID3x8x7x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {33.,  35.,  47.,  49.,  89.,  91.,
                                         103., 105., 145., 147., 159., 161.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, SAME3x8x7x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      47.,  48.,  51.,  52.,  55.,  56.,  55.,  56.,  75.,  76.,  79.,  80.,
      83.,  84.,  83.,  84.,  103., 104., 107., 108., 111., 112., 111., 112.,
      103., 104., 107., 108., 111., 112., 111., 112., 159., 160., 163., 164.,
      167., 168., 167., 168., 187., 188., 191., 192., 195., 196., 195., 196.,
      215., 216., 219., 220., 223., 224., 223., 224., 215., 216., 219., 220.,
      223., 224., 223., 224., 271., 272., 275., 276., 279., 280., 279., 280.,
      299., 300., 303., 304., 307., 308., 307., 308., 327., 328., 331., 332.,
      335., 336., 335., 336., 327., 328., 331., 332., 335., 336., 335., 336.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, VALID3x8x7x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      65.,  66.,  69.,  70.,  93.,  94.,  97.,  98.,  177., 178., 181., 182.,
      205., 206., 209., 210., 289., 290., 293., 294., 317., 318., 321., 322.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, SAME3x8x7x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      93.,  94.,  95.,  96.,  101., 102., 103., 104., 109., 110., 111., 112.,
      109., 110., 111., 112., 149., 150., 151., 152., 157., 158., 159., 160.,
      165., 166., 167., 168., 165., 166., 167., 168., 205., 206., 207., 208.,
      213., 214., 215., 216., 221., 222., 223., 224., 221., 222., 223., 224.,
      205., 206., 207., 208., 213., 214., 215., 216., 221., 222., 223., 224.,
      221., 222., 223., 224., 317., 318., 319., 320., 325., 326., 327., 328.,
      333., 334., 335., 336., 333., 334., 335., 336., 373., 374., 375., 376.,
      381., 382., 383., 384., 389., 390., 391., 392., 389., 390., 391., 392.,
      429., 430., 431., 432., 437., 438., 439., 440., 445., 446., 447., 448.,
      445., 446., 447., 448., 429., 430., 431., 432., 437., 438., 439., 440.,
      445., 446., 447., 448., 445., 446., 447., 448., 541., 542., 543., 544.,
      549., 550., 551., 552., 557., 558., 559., 560., 557., 558., 559., 560.,
      597., 598., 599., 600., 605., 606., 607., 608., 613., 614., 615., 616.,
      613., 614., 615., 616., 653., 654., 655., 656., 661., 662., 663., 664.,
      669., 670., 671., 672., 669., 670., 671., 672., 653., 654., 655., 656.,
      661., 662., 663., 664., 669., 670., 671., 672., 669., 670., 671., 672.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, VALID3x8x7x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      129., 130., 131., 132., 137., 138., 139., 140., 185., 186., 187., 188.,
      193., 194., 195., 196., 353., 354., 355., 356., 361., 362., 363., 364.,
      409., 410., 411., 412., 417., 418., 419., 420., 577., 578., 579., 580.,
      585., 586., 587., 588., 633., 634., 635., 636., 641., 642., 643., 644.};
  const std::array<int, 4> in_shape = {{3, 8, 7, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, SAME3x8x8x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      28.,  30.,  32.,  32.,  44.,  46.,  48.,  48.,  60.,  62.,  64.,  64.,
      60.,  62.,  64.,  64.,  92.,  94.,  96.,  96.,  108., 110., 112., 112.,
      124., 126., 128., 128., 124., 126., 128., 128., 156., 158., 160., 160.,
      172., 174., 176., 176., 188., 190., 192., 192., 188., 190., 192., 192.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, VALID3x8x8x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {37.,  39.,  53.,  55.,  101., 103.,
                                         117., 119., 165., 167., 181., 183.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, SAME3x8x8x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      55.,  56.,  59.,  60.,  63.,  64.,  63.,  64.,  87.,  88.,  91.,  92.,
      95.,  96.,  95.,  96.,  119., 120., 123., 124., 127., 128., 127., 128.,
      119., 120., 123., 124., 127., 128., 127., 128., 183., 184., 187., 188.,
      191., 192., 191., 192., 215., 216., 219., 220., 223., 224., 223., 224.,
      247., 248., 251., 252., 255., 256., 255., 256., 247., 248., 251., 252.,
      255., 256., 255., 256., 311., 312., 315., 316., 319., 320., 319., 320.,
      343., 344., 347., 348., 351., 352., 351., 352., 375., 376., 379., 380.,
      383., 384., 383., 384., 375., 376., 379., 380., 383., 384., 383., 384.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, VALID3x8x8x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      73.,  74.,  77.,  78.,  105., 106., 109., 110., 201., 202., 205., 206.,
      233., 234., 237., 238., 329., 330., 333., 334., 361., 362., 365., 366.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, SAME3x8x8x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      109., 110., 111., 112., 117., 118., 119., 120., 125., 126., 127., 128.,
      125., 126., 127., 128., 173., 174., 175., 176., 181., 182., 183., 184.,
      189., 190., 191., 192., 189., 190., 191., 192., 237., 238., 239., 240.,
      245., 246., 247., 248., 253., 254., 255., 256., 253., 254., 255., 256.,
      237., 238., 239., 240., 245., 246., 247., 248., 253., 254., 255., 256.,
      253., 254., 255., 256., 365., 366., 367., 368., 373., 374., 375., 376.,
      381., 382., 383., 384., 381., 382., 383., 384., 429., 430., 431., 432.,
      437., 438., 439., 440., 445., 446., 447., 448., 445., 446., 447., 448.,
      493., 494., 495., 496., 501., 502., 503., 504., 509., 510., 511., 512.,
      509., 510., 511., 512., 493., 494., 495., 496., 501., 502., 503., 504.,
      509., 510., 511., 512., 509., 510., 511., 512., 621., 622., 623., 624.,
      629., 630., 631., 632., 637., 638., 639., 640., 637., 638., 639., 640.,
      685., 686., 687., 688., 693., 694., 695., 696., 701., 702., 703., 704.,
      701., 702., 703., 704., 749., 750., 751., 752., 757., 758., 759., 760.,
      765., 766., 767., 768., 765., 766., 767., 768., 749., 750., 751., 752.,
      757., 758., 759., 760., 765., 766., 767., 768., 765., 766., 767., 768.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, VALID3x8x8x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      145., 146., 147., 148., 153., 154., 155., 156., 209., 210., 211., 212.,
      217., 218., 219., 220., 401., 402., 403., 404., 409., 410., 411., 412.,
      465., 466., 467., 468., 473., 474., 475., 476., 657., 658., 659., 660.,
      665., 666., 667., 668., 721., 722., 723., 724., 729., 730., 731., 732.};
  const std::array<int, 4> in_shape = {{3, 8, 8, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, SAME3x8x10x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      34.,  36.,  38.,  40.,  40.,  54.,  56.,  58.,  60.,  60.,  74.,  76.,
      78.,  80.,  80.,  74.,  76.,  78.,  80.,  80.,  114., 116., 118., 120.,
      120., 134., 136., 138., 140., 140., 154., 156., 158., 160., 160., 154.,
      156., 158., 160., 160., 194., 196., 198., 200., 200., 214., 216., 218.,
      220., 220., 234., 236., 238., 240., 240., 234., 236., 238., 240., 240.};
  const std::array<int, 4> in_shape = {{3, 8, 10, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, VALID3x8x10x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {45.,  47.,  49.,  65.,  67.,  69.,
                                         125., 127., 129., 145., 147., 149.,
                                         205., 207., 209., 225., 227., 229.};
  const std::array<int, 4> in_shape = {{3, 8, 10, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, SAME3x8x10x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      67.,  68.,  71.,  72.,  75.,  76.,  79.,  80.,  79.,  80.,  107., 108.,
      111., 112., 115., 116., 119., 120., 119., 120., 147., 148., 151., 152.,
      155., 156., 159., 160., 159., 160., 147., 148., 151., 152., 155., 156.,
      159., 160., 159., 160., 227., 228., 231., 232., 235., 236., 239., 240.,
      239., 240., 267., 268., 271., 272., 275., 276., 279., 280., 279., 280.,
      307., 308., 311., 312., 315., 316., 319., 320., 319., 320., 307., 308.,
      311., 312., 315., 316., 319., 320., 319., 320., 387., 388., 391., 392.,
      395., 396., 399., 400., 399., 400., 427., 428., 431., 432., 435., 436.,
      439., 440., 439., 440., 467., 468., 471., 472., 475., 476., 479., 480.,
      479., 480., 467., 468., 471., 472., 475., 476., 479., 480., 479., 480.};
  const std::array<int, 4> in_shape = {{3, 8, 10, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, VALID3x8x10x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      89.,  90.,  93.,  94.,  97.,  98.,  129., 130., 133., 134., 137., 138.,
      249., 250., 253., 254., 257., 258., 289., 290., 293., 294., 297., 298.,
      409., 410., 413., 414., 417., 418., 449., 450., 453., 454., 457., 458.};
  const std::array<int, 4> in_shape = {{3, 8, 10, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, SAME3x8x10x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      133., 134., 135., 136., 141., 142., 143., 144., 149., 150., 151., 152.,
      157., 158., 159., 160., 157., 158., 159., 160., 213., 214., 215., 216.,
      221., 222., 223., 224., 229., 230., 231., 232., 237., 238., 239., 240.,
      237., 238., 239., 240., 293., 294., 295., 296., 301., 302., 303., 304.,
      309., 310., 311., 312., 317., 318., 319., 320., 317., 318., 319., 320.,
      293., 294., 295., 296., 301., 302., 303., 304., 309., 310., 311., 312.,
      317., 318., 319., 320., 317., 318., 319., 320., 453., 454., 455., 456.,
      461., 462., 463., 464., 469., 470., 471., 472., 477., 478., 479., 480.,
      477., 478., 479., 480., 533., 534., 535., 536., 541., 542., 543., 544.,
      549., 550., 551., 552., 557., 558., 559., 560., 557., 558., 559., 560.,
      613., 614., 615., 616., 621., 622., 623., 624., 629., 630., 631., 632.,
      637., 638., 639., 640., 637., 638., 639., 640., 613., 614., 615., 616.,
      621., 622., 623., 624., 629., 630., 631., 632., 637., 638., 639., 640.,
      637., 638., 639., 640., 773., 774., 775., 776., 781., 782., 783., 784.,
      789., 790., 791., 792., 797., 798., 799., 800., 797., 798., 799., 800.,
      853., 854., 855., 856., 861., 862., 863., 864., 869., 870., 871., 872.,
      877., 878., 879., 880., 877., 878., 879., 880., 933., 934., 935., 936.,
      941., 942., 943., 944., 949., 950., 951., 952., 957., 958., 959., 960.,
      957., 958., 959., 960., 933., 934., 935., 936., 941., 942., 943., 944.,
      949., 950., 951., 952., 957., 958., 959., 960., 957., 958., 959., 960.};
  const std::array<int, 4> in_shape = {{3, 8, 10, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, VALID3x8x10x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      177., 178., 179., 180., 185., 186., 187., 188., 193., 194., 195., 196.,
      257., 258., 259., 260., 265., 266., 267., 268., 273., 274., 275., 276.,
      497., 498., 499., 500., 505., 506., 507., 508., 513., 514., 515., 516.,
      577., 578., 579., 580., 585., 586., 587., 588., 593., 594., 595., 596.,
      817., 818., 819., 820., 825., 826., 827., 828., 833., 834., 835., 836.,
      897., 898., 899., 900., 905., 906., 907., 908., 913., 914., 915., 916.};
  const std::array<int, 4> in_shape = {{3, 8, 10, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, SAME3x10x7x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      24.,  26.,  28.,  28.,  38.,  40.,  42.,  42.,  52.,  54.,  56.,  56.,
      66.,  68.,  70.,  70.,  66.,  68.,  70.,  70.,  94.,  96.,  98.,  98.,
      108., 110., 112., 112., 122., 124., 126., 126., 136., 138., 140., 140.,
      136., 138., 140., 140., 164., 166., 168., 168., 178., 180., 182., 182.,
      192., 194., 196., 196., 206., 208., 210., 210., 206., 208., 210., 210.};
  const std::array<int, 4> in_shape = {{3, 10, 7, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, VALID3x10x7x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {33.,  35.,  47.,  49.,  61.,  63.,
                                         103., 105., 117., 119., 131., 133.,
                                         173., 175., 187., 189., 201., 203.};
  const std::array<int, 4> in_shape = {{3, 10, 7, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, SAME3x10x7x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      47.,  48.,  51.,  52.,  55.,  56.,  55.,  56.,  75.,  76.,  79.,  80.,
      83.,  84.,  83.,  84.,  103., 104., 107., 108., 111., 112., 111., 112.,
      131., 132., 135., 136., 139., 140., 139., 140., 131., 132., 135., 136.,
      139., 140., 139., 140., 187., 188., 191., 192., 195., 196., 195., 196.,
      215., 216., 219., 220., 223., 224., 223., 224., 243., 244., 247., 248.,
      251., 252., 251., 252., 271., 272., 275., 276., 279., 280., 279., 280.,
      271., 272., 275., 276., 279., 280., 279., 280., 327., 328., 331., 332.,
      335., 336., 335., 336., 355., 356., 359., 360., 363., 364., 363., 364.,
      383., 384., 387., 388., 391., 392., 391., 392., 411., 412., 415., 416.,
      419., 420., 419., 420., 411., 412., 415., 416., 419., 420., 419., 420.};
  const std::array<int, 4> in_shape = {{3, 10, 7, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, VALID3x10x7x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      65.,  66.,  69.,  70.,  93.,  94.,  97.,  98.,  121., 122., 125., 126.,
      205., 206., 209., 210., 233., 234., 237., 238., 261., 262., 265., 266.,
      345., 346., 349., 350., 373., 374., 377., 378., 401., 402., 405., 406.};
  const std::array<int, 4> in_shape = {{3, 10, 7, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, SAME3x10x7x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      93.,  94.,  95.,  96.,  101., 102., 103., 104., 109., 110., 111., 112.,
      109., 110., 111., 112., 149., 150., 151., 152., 157., 158., 159., 160.,
      165., 166., 167., 168., 165., 166., 167., 168., 205., 206., 207., 208.,
      213., 214., 215., 216., 221., 222., 223., 224., 221., 222., 223., 224.,
      261., 262., 263., 264., 269., 270., 271., 272., 277., 278., 279., 280.,
      277., 278., 279., 280., 261., 262., 263., 264., 269., 270., 271., 272.,
      277., 278., 279., 280., 277., 278., 279., 280., 373., 374., 375., 376.,
      381., 382., 383., 384., 389., 390., 391., 392., 389., 390., 391., 392.,
      429., 430., 431., 432., 437., 438., 439., 440., 445., 446., 447., 448.,
      445., 446., 447., 448., 485., 486., 487., 488., 493., 494., 495., 496.,
      501., 502., 503., 504., 501., 502., 503., 504., 541., 542., 543., 544.,
      549., 550., 551., 552., 557., 558., 559., 560., 557., 558., 559., 560.,
      541., 542., 543., 544., 549., 550., 551., 552., 557., 558., 559., 560.,
      557., 558., 559., 560., 653., 654., 655., 656., 661., 662., 663., 664.,
      669., 670., 671., 672., 669., 670., 671., 672., 709., 710., 711., 712.,
      717., 718., 719., 720., 725., 726., 727., 728., 725., 726., 727., 728.,
      765., 766., 767., 768., 773., 774., 775., 776., 781., 782., 783., 784.,
      781., 782., 783., 784., 821., 822., 823., 824., 829., 830., 831., 832.,
      837., 838., 839., 840., 837., 838., 839., 840., 821., 822., 823., 824.,
      829., 830., 831., 832., 837., 838., 839., 840., 837., 838., 839., 840.};
  const std::array<int, 4> in_shape = {{3, 10, 7, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, VALID3x10x7x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      129., 130., 131., 132., 137., 138., 139., 140., 185., 186., 187., 188.,
      193., 194., 195., 196., 241., 242., 243., 244., 249., 250., 251., 252.,
      409., 410., 411., 412., 417., 418., 419., 420., 465., 466., 467., 468.,
      473., 474., 475., 476., 521., 522., 523., 524., 529., 530., 531., 532.,
      689., 690., 691., 692., 697., 698., 699., 700., 745., 746., 747., 748.,
      753., 754., 755., 756., 801., 802., 803., 804., 809., 810., 811., 812.};
  const std::array<int, 4> in_shape = {{3, 10, 7, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, SAME3x10x8x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      28.,  30.,  32.,  32.,  44.,  46.,  48.,  48.,  60.,  62.,  64.,  64.,
      76.,  78.,  80.,  80.,  76.,  78.,  80.,  80.,  108., 110., 112., 112.,
      124., 126., 128., 128., 140., 142., 144., 144., 156., 158., 160., 160.,
      156., 158., 160., 160., 188., 190., 192., 192., 204., 206., 208., 208.,
      220., 222., 224., 224., 236., 238., 240., 240., 236., 238., 240., 240.};
  const std::array<int, 4> in_shape = {{3, 10, 8, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, VALID3x10x8x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {37.,  39.,  53.,  55.,  69.,  71.,
                                         117., 119., 133., 135., 149., 151.,
                                         197., 199., 213., 215., 229., 231.};
  const std::array<int, 4> in_shape = {{3, 10, 8, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, SAME3x10x8x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      55.,  56.,  59.,  60.,  63.,  64.,  63.,  64.,  87.,  88.,  91.,  92.,
      95.,  96.,  95.,  96.,  119., 120., 123., 124., 127., 128., 127., 128.,
      151., 152., 155., 156., 159., 160., 159., 160., 151., 152., 155., 156.,
      159., 160., 159., 160., 215., 216., 219., 220., 223., 224., 223., 224.,
      247., 248., 251., 252., 255., 256., 255., 256., 279., 280., 283., 284.,
      287., 288., 287., 288., 311., 312., 315., 316., 319., 320., 319., 320.,
      311., 312., 315., 316., 319., 320., 319., 320., 375., 376., 379., 380.,
      383., 384., 383., 384., 407., 408., 411., 412., 415., 416., 415., 416.,
      439., 440., 443., 444., 447., 448., 447., 448., 471., 472., 475., 476.,
      479., 480., 479., 480., 471., 472., 475., 476., 479., 480., 479., 480.};
  const std::array<int, 4> in_shape = {{3, 10, 8, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, VALID3x10x8x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      73.,  74.,  77.,  78.,  105., 106., 109., 110., 137., 138., 141., 142.,
      233., 234., 237., 238., 265., 266., 269., 270., 297., 298., 301., 302.,
      393., 394., 397., 398., 425., 426., 429., 430., 457., 458., 461., 462.};
  const std::array<int, 4> in_shape = {{3, 10, 8, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, SAME3x10x8x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      109., 110., 111., 112., 117., 118., 119., 120., 125., 126., 127., 128.,
      125., 126., 127., 128., 173., 174., 175., 176., 181., 182., 183., 184.,
      189., 190., 191., 192., 189., 190., 191., 192., 237., 238., 239., 240.,
      245., 246., 247., 248., 253., 254., 255., 256., 253., 254., 255., 256.,
      301., 302., 303., 304., 309., 310., 311., 312., 317., 318., 319., 320.,
      317., 318., 319., 320., 301., 302., 303., 304., 309., 310., 311., 312.,
      317., 318., 319., 320., 317., 318., 319., 320., 429., 430., 431., 432.,
      437., 438., 439., 440., 445., 446., 447., 448., 445., 446., 447., 448.,
      493., 494., 495., 496., 501., 502., 503., 504., 509., 510., 511., 512.,
      509., 510., 511., 512., 557., 558., 559., 560., 565., 566., 567., 568.,
      573., 574., 575., 576., 573., 574., 575., 576., 621., 622., 623., 624.,
      629., 630., 631., 632., 637., 638., 639., 640., 637., 638., 639., 640.,
      621., 622., 623., 624., 629., 630., 631., 632., 637., 638., 639., 640.,
      637., 638., 639., 640., 749., 750., 751., 752., 757., 758., 759., 760.,
      765., 766., 767., 768., 765., 766., 767., 768., 813., 814., 815., 816.,
      821., 822., 823., 824., 829., 830., 831., 832., 829., 830., 831., 832.,
      877., 878., 879., 880., 885., 886., 887., 888., 893., 894., 895., 896.,
      893., 894., 895., 896., 941., 942., 943., 944., 949., 950., 951., 952.,
      957., 958., 959., 960., 957., 958., 959., 960., 941., 942., 943., 944.,
      949., 950., 951., 952., 957., 958., 959., 960., 957., 958., 959., 960.};
  const std::array<int, 4> in_shape = {{3, 10, 8, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, VALID3x10x8x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      145., 146., 147., 148., 153., 154., 155., 156., 209., 210., 211., 212.,
      217., 218., 219., 220., 273., 274., 275., 276., 281., 282., 283., 284.,
      465., 466., 467., 468., 473., 474., 475., 476., 529., 530., 531., 532.,
      537., 538., 539., 540., 593., 594., 595., 596., 601., 602., 603., 604.,
      785., 786., 787., 788., 793., 794., 795., 796., 849., 850., 851., 852.,
      857., 858., 859., 860., 913., 914., 915., 916., 921., 922., 923., 924.};
  const std::array<int, 4> in_shape = {{3, 10, 8, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, SAME3x10x10x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      34.,  36.,  38.,  40.,  40.,  54.,  56.,  58.,  60.,  60.,  74.,
      76.,  78.,  80.,  80.,  94.,  96.,  98.,  100., 100., 94.,  96.,
      98.,  100., 100., 134., 136., 138., 140., 140., 154., 156., 158.,
      160., 160., 174., 176., 178., 180., 180., 194., 196., 198., 200.,
      200., 194., 196., 198., 200., 200., 234., 236., 238., 240., 240.,
      254., 256., 258., 260., 260., 274., 276., 278., 280., 280., 294.,
      296., 298., 300., 300., 294., 296., 298., 300., 300.};
  const std::array<int, 4> in_shape = {{3, 10, 10, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, VALID3x10x10x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      45.,  47.,  49.,  65.,  67.,  69.,  85.,  87.,  89.,
      145., 147., 149., 165., 167., 169., 185., 187., 189.,
      245., 247., 249., 265., 267., 269., 285., 287., 289.};
  const std::array<int, 4> in_shape = {{3, 10, 10, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, SAME3x10x10x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      67.,  68.,  71.,  72.,  75.,  76.,  79.,  80.,  79.,  80.,  107., 108.,
      111., 112., 115., 116., 119., 120., 119., 120., 147., 148., 151., 152.,
      155., 156., 159., 160., 159., 160., 187., 188., 191., 192., 195., 196.,
      199., 200., 199., 200., 187., 188., 191., 192., 195., 196., 199., 200.,
      199., 200., 267., 268., 271., 272., 275., 276., 279., 280., 279., 280.,
      307., 308., 311., 312., 315., 316., 319., 320., 319., 320., 347., 348.,
      351., 352., 355., 356., 359., 360., 359., 360., 387., 388., 391., 392.,
      395., 396., 399., 400., 399., 400., 387., 388., 391., 392., 395., 396.,
      399., 400., 399., 400., 467., 468., 471., 472., 475., 476., 479., 480.,
      479., 480., 507., 508., 511., 512., 515., 516., 519., 520., 519., 520.,
      547., 548., 551., 552., 555., 556., 559., 560., 559., 560., 587., 588.,
      591., 592., 595., 596., 599., 600., 599., 600., 587., 588., 591., 592.,
      595., 596., 599., 600., 599., 600.};
  const std::array<int, 4> in_shape = {{3, 10, 10, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, VALID3x10x10x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      89.,  90.,  93.,  94.,  97.,  98.,  129., 130., 133., 134., 137.,
      138., 169., 170., 173., 174., 177., 178., 289., 290., 293., 294.,
      297., 298., 329., 330., 333., 334., 337., 338., 369., 370., 373.,
      374., 377., 378., 489., 490., 493., 494., 497., 498., 529., 530.,
      533., 534., 537., 538., 569., 570., 573., 574., 577., 578.};
  const std::array<int, 4> in_shape = {{3, 10, 10, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, SAME3x10x10x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      133.,  134.,  135.,  136.,  141.,  142.,  143.,  144.,  149.,  150.,
      151.,  152.,  157.,  158.,  159.,  160.,  157.,  158.,  159.,  160.,
      213.,  214.,  215.,  216.,  221.,  222.,  223.,  224.,  229.,  230.,
      231.,  232.,  237.,  238.,  239.,  240.,  237.,  238.,  239.,  240.,
      293.,  294.,  295.,  296.,  301.,  302.,  303.,  304.,  309.,  310.,
      311.,  312.,  317.,  318.,  319.,  320.,  317.,  318.,  319.,  320.,
      373.,  374.,  375.,  376.,  381.,  382.,  383.,  384.,  389.,  390.,
      391.,  392.,  397.,  398.,  399.,  400.,  397.,  398.,  399.,  400.,
      373.,  374.,  375.,  376.,  381.,  382.,  383.,  384.,  389.,  390.,
      391.,  392.,  397.,  398.,  399.,  400.,  397.,  398.,  399.,  400.,
      533.,  534.,  535.,  536.,  541.,  542.,  543.,  544.,  549.,  550.,
      551.,  552.,  557.,  558.,  559.,  560.,  557.,  558.,  559.,  560.,
      613.,  614.,  615.,  616.,  621.,  622.,  623.,  624.,  629.,  630.,
      631.,  632.,  637.,  638.,  639.,  640.,  637.,  638.,  639.,  640.,
      693.,  694.,  695.,  696.,  701.,  702.,  703.,  704.,  709.,  710.,
      711.,  712.,  717.,  718.,  719.,  720.,  717.,  718.,  719.,  720.,
      773.,  774.,  775.,  776.,  781.,  782.,  783.,  784.,  789.,  790.,
      791.,  792.,  797.,  798.,  799.,  800.,  797.,  798.,  799.,  800.,
      773.,  774.,  775.,  776.,  781.,  782.,  783.,  784.,  789.,  790.,
      791.,  792.,  797.,  798.,  799.,  800.,  797.,  798.,  799.,  800.,
      933.,  934.,  935.,  936.,  941.,  942.,  943.,  944.,  949.,  950.,
      951.,  952.,  957.,  958.,  959.,  960.,  957.,  958.,  959.,  960.,
      1013., 1014., 1015., 1016., 1021., 1022., 1023., 1024., 1029., 1030.,
      1031., 1032., 1037., 1038., 1039., 1040., 1037., 1038., 1039., 1040.,
      1093., 1094., 1095., 1096., 1101., 1102., 1103., 1104., 1109., 1110.,
      1111., 1112., 1117., 1118., 1119., 1120., 1117., 1118., 1119., 1120.,
      1173., 1174., 1175., 1176., 1181., 1182., 1183., 1184., 1189., 1190.,
      1191., 1192., 1197., 1198., 1199., 1200., 1197., 1198., 1199., 1200.,
      1173., 1174., 1175., 1176., 1181., 1182., 1183., 1184., 1189., 1190.,
      1191., 1192., 1197., 1198., 1199., 1200., 1197., 1198., 1199., 1200.};
  const std::array<int, 4> in_shape = {{3, 10, 10, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxwithnanWindow5Stride2Forward, VALID3x10x10x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      177.,  178.,  179.,  180.,  185.,  186.,  187.,  188.,  193.,  194.,
      195.,  196.,  257.,  258.,  259.,  260.,  265.,  266.,  267.,  268.,
      273.,  274.,  275.,  276.,  337.,  338.,  339.,  340.,  345.,  346.,
      347.,  348.,  353.,  354.,  355.,  356.,  577.,  578.,  579.,  580.,
      585.,  586.,  587.,  588.,  593.,  594.,  595.,  596.,  657.,  658.,
      659.,  660.,  665.,  666.,  667.,  668.,  673.,  674.,  675.,  676.,
      737.,  738.,  739.,  740.,  745.,  746.,  747.,  748.,  753.,  754.,
      755.,  756.,  977.,  978.,  979.,  980.,  985.,  986.,  987.,  988.,
      993.,  994.,  995.,  996.,  1057., 1058., 1059., 1060., 1065., 1066.,
      1067., 1068., 1073., 1074., 1075., 1076., 1137., 1138., 1139., 1140.,
      1145., 1146., 1147., 1148., 1153., 1154., 1155., 1156.};
  const std::array<int, 4> in_shape = {{3, 10, 10, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<5, 2>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
